home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2009 February / PCWFEB09.iso / Software / Resources / Chat & Communication / Digsby build 37 / digsby_setup.exe / lib / protocols / generate.pyo (.txt) < prev    next >
Python Compiled Bytecode  |  2008-10-13  |  6KB  |  180 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.5)
  3.  
  4. from interfaces import Protocol, allocate_lock, Interface
  5. from advice import metamethod, supermeta
  6. from api import declareAdapterForProtocol, declareAdapterForType
  7. from api import declareAdapter, adapt
  8. from adapters import NO_ADAPTER_NEEDED
  9. __all__ = [
  10.     'protocolForType',
  11.     'protocolForURI',
  12.     'sequenceOf',
  13.     'IBasicSequence',
  14.     'URIProtocol',
  15.     'TypeSubset',
  16.     'WeakSubset',
  17.     'ADAPT_SEQUENCE',
  18.     'SequenceProtocol']
  19.  
  20. class URIProtocol(Protocol):
  21.     
  22.     def __init__(self, uri):
  23.         self.URI = uri
  24.         Protocol.__init__(self)
  25.  
  26.     
  27.     def __repr__(self):
  28.         return 'URIProtocol(%r)' % self.URI
  29.  
  30.     
  31.     def __reduce__(self):
  32.         return (protocolForURI, (self.URI,))
  33.  
  34.  
  35.  
  36. class TypeSubset(Protocol):
  37.     
  38.     def __init__(self, baseType, methods):
  39.         self.baseType = baseType
  40.         self.methods = methods
  41.         Protocol.__init__(self)
  42.  
  43.     
  44.     def __repr__(self):
  45.         return 'TypeSubset(%r,%r)' % (self.baseType, self.methods)
  46.  
  47.     
  48.     def __reduce__(self):
  49.         return (protocolForType, (self.baseType, self.methods, False))
  50.  
  51.  
  52.  
  53. class WeakSubset(TypeSubset, object):
  54.     __metaclass__ = type
  55.     
  56.     def __adapt__(self, ob):
  57.         result = supermeta(TypeSubset, self).__adapt__(ob)
  58.         if result is not None:
  59.             return result
  60.         
  61.         for name in self.methods:
  62.             if not hasattr(ob, name):
  63.                 return None
  64.                 continue
  65.         else:
  66.             return ob
  67.  
  68.     __adapt__ = metamethod(__adapt__)
  69.     
  70.     def __repr__(self):
  71.         return 'WeakSubset(%r,%r)' % (self.baseType, self.methods)
  72.  
  73.     
  74.     def __reduce__(self):
  75.         return (protocolForType, (self.baseType, self.methods, True))
  76.  
  77.  
  78.  
  79. class SequenceProtocol(Protocol):
  80.     
  81.     def __init__(self, baseProtocol):
  82.         self.baseProtocol = baseProtocol
  83.         Protocol.__init__(self)
  84.  
  85.     
  86.     def __repr__(self):
  87.         return 'sequenceOf(%r)' % self.baseProtocol
  88.  
  89.     
  90.     def __reduce__(self):
  91.         return (sequenceOf, (self.baseProtocol,))
  92.  
  93.  
  94.  
  95. class IBasicSequence(Interface):
  96.     
  97.     def __iter__():
  98.         pass
  99.  
  100.  
  101. declareAdapter(NO_ADAPTER_NEEDED, provides = [
  102.     IBasicSequence], forTypes = [
  103.     list,
  104.     tuple])
  105.  
  106. def ADAPT_SEQUENCE(ob, proto):
  107.     marker = object()
  108.     out = []
  109.     proto = proto.baseProtocol
  110.     for item in ob:
  111.         item = adapt(item, proto, marker)
  112.         if item is marker:
  113.             return None
  114.         
  115.         out.append(item)
  116.     
  117.     return out
  118.  
  119. __registryLock = allocate_lock()
  120. registry = { }
  121.  
  122. def protocolForURI(uri):
  123.     __registryLock.acquire()
  124.     
  125.     try:
  126.         return registry[uri]
  127.     except KeyError:
  128.         proto = registry[uri] = URIProtocol(uri)
  129.         return proto
  130.     finally:
  131.         __registryLock.release()
  132.  
  133.  
  134.  
  135. def protocolForType(baseType, methods = (), implicit = False):
  136.     methods = []([ (k, k) for k in methods ]).keys()
  137.     methods.sort()
  138.     methods = tuple(methods)
  139.     key = (baseType, methods, not (not implicit))
  140.     return __protocolForType(key)
  141.  
  142.  
  143. def sequenceOf(baseProtocol):
  144.     key = (sequenceOf, baseProtocol)
  145.     __registryLock.acquire()
  146.     
  147.     try:
  148.         return registry[key]
  149.     except KeyError:
  150.         proto = registry[key] = SequenceProtocol(baseProtocol)
  151.         declareAdapterForProtocol((proto,), (lambda o: ADAPT_SEQUENCE(o, proto)), IBasicSequence)
  152.         return proto
  153.     finally:
  154.         __registryLock.release()
  155.  
  156.  
  157.  
  158. def __protocolForType(key):
  159.     __registryLock.acquire()
  160.     
  161.     try:
  162.         return registry[key]
  163.     except KeyError:
  164.         (baseType, methods, implicit) = key
  165.         if implicit:
  166.             proto = WeakSubset(baseType, methods)
  167.         else:
  168.             proto = TypeSubset(baseType, methods)
  169.         registry[key] = proto
  170.     finally:
  171.         __registryLock.release()
  172.  
  173.     if implicit:
  174.         impliedBy = __protocolForType((baseType, methods, False))
  175.         declareAdapterForProtocol(proto, NO_ADAPTER_NEEDED, impliedBy)
  176.     
  177.     declareAdapterForType(proto, NO_ADAPTER_NEEDED, baseType)
  178.     return proto
  179.  
  180.